// #pragma once
#ifndef __M_SERVER_H__
#define __M_SERVER_H__
#include <iostream>
#include <vector>
#include <cassert>
#include <cstring>
#include <string>
#include <ctime>
#include <pthread.h>
#define BUFFER_DEFAULT_SIZE 1024

#define INF 0
#define DBG 1
#define ERR 2
#define LOG_LEVEL ERR // 控制： 调整打印等级至INF的等级才能打印

#define LOG(LEVEL, format, ...)                                                                        \
    do                                                                                                 \
    {                                                                                                  \
        if (LEVEL < LOG_LEVEL)                                                                         \
            break;                                                                                     \
        time_t t = time(nullptr);                                                                      \
        struct tm *ltm = localtime(&t);                                                                \
        char tmp[32] = {0};                                                                            \
        strftime(tmp, 31, "%H:%M:%S", ltm);                                                            \
        fprintf(stdout, "[%p %s:%s:%d] " format "\n", (void *)pthread_self(), tmp, __FILE__, __LINE__, \
                ##__VA_ARGS__);                                                                        \
    } while (0)

#define INF_LOG(format, ...) LOG(INF, format, ##__VA_ARGS__)
#define DBG_LOG(format, ...) LOG(DBG, format, ##__VA_ARGS__)
#define ERR_LOG(format, ...) LOG(ERR, format, ##__VA_ARGS__)

class Buffer
{
private:
    std::vector<char> _buffer;
    /*是一个相对偏移量，而不是绝对地址*/
    uint64_t _read_idx;   // 相对读偏移量
    uint64_t _writer_idx; // 相对写偏移量

public:
    // 构造函数
    Buffer() : _read_idx(0), _writer_idx(0), _buffer(BUFFER_DEFAULT_SIZE) {}
    char *Begin()
    {
        // &*_buffer.begin(): 迭代器buffer.begin()指向起始元素，*buffer.begin()
        // &*_buffer.begin()--->得到第0个元素的空间地址
        return &*_buffer.begin();
    }
    // 获取当前写位置地址：_Buffer的空间起始地址，加上写偏移量
    char *WritePosition()
    {
        // 将获取_buffer起始地址的过程用begin()封装起来
        return Begin() + _writer_idx;
    }
    // 获取当前读位置地址
    char *ReadPosition()
    {
        return Begin() + _read_idx;
    }
    // 获取前沿空闲空间大小：读偏移
    uint64_t HeadIdleSize()
    {
        return _read_idx;
    }
    // 获取后沿空闲空间大小：总体空间大小-写偏移
    uint64_t TailIdleSize()
    {
        return _buffer.size() - _writer_idx;
    }
    // 获取可写空间大小
    uint64_t WritableSize()
    {
        return HeadIdleSize() + TailIdleSize();
    }
    // 获取可读数据大小：写偏移-读偏移
    uint64_t ReadableSize()
    {
        return _writer_idx - _read_idx;
    }
    // 将读偏移向后移动指定长度
    void MoveReadOffset(uint64_t len)
    {
        if (len == 0)
            return;
        // 向后移动的大小，必须小于可读数据大小
        assert(len <= ReadableSize());
        _read_idx += len;
    }
    // 将写偏移向后移动指定长度
    void MoveWriteOffset(uint64_t len)
    {
        // 向后移动的大小，必须小于当前后边的空闲空间大小
        assert(len <= TailIdleSize());

        _writer_idx += len;
    }
    // 确保可写空间足够（移动+扩容）
    void EnsureWriteSpace(uint64_t len)
    {
        if (TailIdleSize() >= len)
        {
            return;
        }
        // 末尾空闲空间不够：则判断加上前沿空闲空间大小是否足够，足够就挪动数据
        if (HeadIdleSize() + TailIdleSize() >= len)
        {
            // 移动数据至起始位置先保存好当前数据大小
            uint64_t rsz = ReadableSize(); // 先保存好当前数据大小
                                           // 将可读数据拷贝到起始位置
            // 将可读数据拷贝到起始位置，注意类型转换
            std::copy(ReadPosition(), ReadPosition() + rsz, Begin());
            _read_idx = 0;
            _writer_idx = rsz;
        }
        else
        {
            // 总体空间不够，需要扩容，不移动数据，直接给写偏移之后扩容足够空间：
            _buffer.resize(_writer_idx + len);
        }
    }
    // 写入数据
    void Write(const void *data, uint64_t len)
    {
        // 1.确保有足够的空间，2.拷贝数据进去
        if (len == 0)
            return;
        EnsureWriteSpace(len);
        const char *d = (const char *)data;

        std::copy((char *)data, (char *)(d + len), WritePosition());
    }

    void WriteAndPush(const void *data, uint64_t len)
    {
        Write(data, len);
        MoveWriteOffset(len);
    }

    void WriteString(const std::string &data)
    {
        return Write(data.c_str(), data.size());
    }
    void WriteStringAndPush(const std::string &data)
    {
        WriteString(data);
        // std::cout << WritePosition() << std::endl;//测试
        MoveWriteOffset(data.size());
        // std::cout << ReadableSize() << std::endl;//测试
    }
    void WriteBuffer(Buffer &data)
    {
        return Write(data.ReadPosition(), data.ReadableSize());
    }
    void WriteBufferAndPush(Buffer &data)
    {
        WriteBuffer(data);
        MoveWriteOffset(data.ReadableSize());
    }
    // 读取数据
    void Read(void *buf, uint64_t len)
    {
        assert(len <= ReadableSize());
        // std::cout << "------" << std::endl;// 测试
        // std::cout << ReadPosition() << std::endl; // 测试
        std::copy(ReadPosition(), ReadPosition() + len, (char *)buf);
        // std::cout << buf << std::endl; // 测试
    }

    // 读并弹出
    void ReadAndPop(void *buf, uint64_t len)
    {
        Read(buf, len);
        MoveReadOffset(len);
    }

    std::string ReadAsString(uint64_t len)
    {
        assert(len <= ReadableSize());
        std::string str;
        str.resize(len);
        Read(&str[0], len);
        // std::cout << "******" << std::endl; // 测试
        // std::cout << str << std::endl;      // 测试
        return str;
    }

    std::string ReadAsStringAndPop(uint64_t len)
    {
        assert(len <= ReadableSize());
        std::string str = ReadAsString(len);
        MoveReadOffset(len);
        // std::cout << "++++++" << std::endl; // 测试
        // std::cout << str << std::endl;      // 测试
        return str;
    }

    // 寻找换行字符
    char *FindCRLF()
    {
        char *res = (char *)memchr(ReadPosition(), '\n', ReadableSize());
        return res;
    }

    // 获取一行数据
    //  通常获取一行数据，这种情况针对的是
    std::string GetLine()
    {
        char *pos = FindCRLF();
        if (pos == nullptr)
        {
            return "";
        }
        //+1是为了把换行字符也取出
        return ReadAsString(pos - ReadPosition() + 1);
    }
    std::string GetLineAndPop()
    {
        std::string str = GetLine();
        MoveReadOffset(str.size());
        return str;
    }
    // 清理功能：读写偏移归0
    void Clear()
    {
        _read_idx = 0;
        _writer_idx = 0;
    }
};

#include <sys/socket.h>
#include <sys/types.h>

#include <netinet/in.h>
#include <arpa/inet.h> //字节序转换
#include <unistd.h>
#include <fcntl.h>

#define Max_LISTEN 1024
class Socket
{
private:
    int _sockfd;

public:
    Socket() : _sockfd(-1) {}
    Socket(int fd) : _sockfd(fd) {}
    ~Socket() { Close(); }
    int Fd()
    {
        return _sockfd;
    }
    // 创建套接字
    bool Create()
    {
        // int socket(int domain ,int type, int protocol);
        _sockfd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
        if (_sockfd < 0)
        {
            ERR_LOG("CREATE SOCKET FAILED...");
            return false;
        }
        return true;
    }
    // 绑定地址信息
    bool Bind(const std::string &ip, uint16_t port)
    {
        struct sockaddr_in addr;
        addr.sin_family = AF_INET;
        addr.sin_port = htons(port);
        addr.sin_addr.s_addr = inet_addr(ip.c_str());
        socklen_t len = sizeof(struct sockaddr_in);
        // int bind(int sockfd, struct sockaddr *addr, socklen_t len);
        int ret = bind(_sockfd, (struct sockaddr *)&addr, len);
        if (ret < 0)
        {
            ERR_LOG("BIND ADDRESS FAILED...");
            return false;
        }
        return true;
    }
    // 开始监听
    bool Listen(int backlog)
    {
        // int listen(int socket, int backlog); // backlog:设置以下同一时间最大并发连接数
        int ret = listen(_sockfd, backlog);
        if (ret < 0)
        {
            ERR_LOG("SOCKET LISTEN FAILED...");
            return false;
        }
        return true;
    }
    // 向服务器发起连接
    bool Connect(const std::string &ip, uint16_t port)
    {
        struct sockaddr_in addr;
        addr.sin_family = AF_INET;
        addr.sin_port = htons(port);
        addr.sin_addr.s_addr = inet_addr(ip.c_str());
        socklen_t len = sizeof(struct sockaddr_in);
        // int connect(int sockfd, struct sockaddr *addr, socklen_t len);
        int ret = connect(_sockfd, (struct sockaddr *)&addr, len);
        if (ret < 0)
        {
            ERR_LOG("CONNECT SERVER FAILED...");
            return false;
        }
        return true;
    }
    // 获取新连接: 返回文件描述符
    int Accept()
    {
        // int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen);
        int newfd = accept(_sockfd, nullptr, nullptr);
        if (newfd < 0)
        {
            ERR_LOG("SOCKET ACCEPT FAILED...");
            return -1;
        }
        return newfd;
    }
    // 接收数据
    // ssize_t：有符号的长整型, flag = 0：默认阻塞操作
    ssize_t Recv(void *buf, size_t len, int flag = 0)
    {
        // ssize_t recv(int sockfd, void *buf, size_t len, int flags);
        ssize_t ret = recv(_sockfd, buf, len, flag);
        if (ret <= 0)
        {
            // EAGAIN: 当前socket的接收缓冲区中没有数据了，在非阻塞的情况下才会有这个错误
            // EINTR: 当前socket的阻塞等待，被信号打断了，
            if (errno == EAGAIN || errno == EINTR)
            {
                ERR_LOG("SOCKET RECV NULL...");

                return 0; // 表示这次没有接收到数据
            }
            ERR_LOG("SOCKET RECV FAILED...");
            return -1;
        }
        // INF_LOG("%ld", ret);
        return ret; // 实际接收到的数据长度
    }

    // 非阻塞接收数据
    ssize_t NonBlockRecv(void *buf, size_t len)
    {
        return Recv(buf, len, MSG_DONTWAIT); // MSG_DONTWAIT: 表示当前接收为非阻塞
    }

    // 发送数据
    ssize_t Send(const void *buf, size_t len, int flag = 0)
    {
        // ssize_t send(int sockfd, const void *buf, size_t len, int flags);

        ssize_t ret = send(_sockfd, buf, len, flag);
        if (ret < 0)
        {
            if (errno == EAGAIN || errno == EINTR)
            {
                ERR_LOG("SOCKET SEND NULL...");

                return 0; // 表示这次没有接收到数据
            }
            ERR_LOG("SOCKET SEND FAILED...");
            return -1;
        }
        // ret: 实际发送的数据长度，有可能buf中数据并没有发送完，外部可以根据实际发送长度来决定如何继续处理
        // std::cout << ret << std::endl;
        return ret;
    }

    // 非阻塞发送数据
    ssize_t NonBlockSend(void *buf, size_t len)
    {
        if (len == 0)
        {
            return 0;
        }
        return Send(buf, len, MSG_DONTWAIT); // MSG_DONTWAIT: 表示当前发送为非阻塞
    }

    // 关闭套接字
    void Close()
    {
        if (_sockfd != -1)
        {
            close(_sockfd);
            _sockfd = -1;
        }
    }
    // 套接字其余重要操作
    //  创建一个服务端（监听）连接, 主机一般会绑定当前主机上所有的网卡
    bool CreateServer(uint16_t port, const std::string &ip = "0.0.0.0", bool block_flag = false)
    {
        // 1.创建套接字 2.绑定地址 3.开始监听 4.设置非阻塞 5.启动地址重用
        if (Create() == false)
            return false;
        if (block_flag)
            NonBlock();
        if (Bind(ip, port) == false)
            return false;
        if (Listen(Max_LISTEN) == false)
            return false;

        ReuseAddress();
        return true;
    }
    // 创建一个客户端连接
    bool CreateClient(uint16_t port, const std::string &ip)
    {
        // 1.创建套接字 2.直接连接服务器 3.开始监听 4.设置非阻塞 5.启动地址重用
        if (Create() == false)
        {
            DBG_LOG("SOCKET CREATECLIENT FAILED...");
            return false;
        }

        if (Connect(ip, port) == false)
            return false;
        INF_LOG("SOCKET CREATECLIENT SUCCESS...");

        return true;
    }
    // 设置套接字选项--开启地址端口重用
    void ReuseAddress()
    {
        //  int setsockopt(int sockfd, int level, int optname,
        //               const void *optval, socklen_t optlen);

        int val = 1;
        // 地址重用
        setsockopt(_sockfd, SOL_SOCKET, SO_REUSEADDR, (void *)&val, sizeof(int));
        val = 1;
        // 端口重用
        setsockopt(_sockfd, SOL_SOCKET, SO_REUSEPORT, (void *)&val, sizeof(int));
    }
    // 设置套接字阻塞属性--设置为非阻塞（因为默认是阻塞）
    void NonBlock()
    {
        // int fcntl(int fd, int cmd, ... /* arg */ );
        int flag = fcntl(_sockfd, F_GETFL, 0);
        fcntl(_sockfd, F_SETFL, flag | O_NONBLOCK);
    }
};

#include <functional>
#include <sys/epoll.h>
class EventLoop;
class Channel
{
private:
    int _fd;
    EventLoop *_loop;
    uint32_t _events;  // 当前需要监控的事件
    uint32_t _revents; // 当前连接触发的事件
    using EventCallBack = std::function<void()>;
    EventCallBack _read_callback;     // 可读事件被触发的回调函数
    EventCallBack _write_callback;    // 可写事件被触发的回调函数
    EventCallBack _error_callback;    // 错误事件被触发的回调函数
    EventCallBack _close_callback;    // 连接断开事件被触发的回调函数
    EventCallBack _anyevent_callback; // 任意事件被触发的回调函数
public:
    Channel(EventLoop *loop, int fd) : _fd(fd), _events(0), _revents(0), _loop(loop) {}
    int Fd() { return _fd; }
    // 进行事件监控之后，fd就绪了的事件，
    // EventLoop就会通过这个接口把实际就绪的事件设置进来，根据revents判断什么事件就绪
    uint32_t Events() { return _events; } // 获取想要监控的事件

    void SetREvent(uint32_t events)
    {
        _revents = events;
    }
    // 设置事件回调，你传函数，我回调
    void SetReadCallBack(const EventCallBack &cb)
    {
        _read_callback = cb;
    }
    void SetWriteCallBack(const EventCallBack &cb)
    {
        _write_callback = cb;
    }
    void SetErrorCallBack(const EventCallBack &cb)
    {
        _error_callback = cb;
    }
    void SetCloseCallBack(const EventCallBack &cb)
    {
        _close_callback = cb;
    }
    void SetAnyEventCallBack(const EventCallBack &cb)
    {
        _anyevent_callback = cb;
    }
    // 当前是否监控可读
    bool Readable()
    {
        return _events & EPOLLIN;
    }
    // 当前是否监控可写
    bool Writable()
    {
        return _events & EPOLLOUT;
    }
    // 启动读事件监控 -->挂到EventLoop上
    void EnableRead()
    {
        _events |= EPOLLIN;
        Update();
    }

    // 启动写事件监控
    void EnableWrite()
    {
        _events |= EPOLLOUT;
        Update();
    }
    // 解除可读事件监控
    void DisableRead()
    {
        _events &= ~EPOLLIN;
        Update();
    }
    // 解除可写事件监控
    void DisableWrite()
    {
        _events &= ~EPOLLOUT;
        Update();
    }
    // 解除所有事件监控
    void DisableAll()
    {
        _events = 0;
        Update();
    }
    // 这里做声明，在Poller类之后实现
    // 移除监控：从epoll红黑树上直接移除，从EventLoop上移除
    void Remove();
    // 更新监控
    void Update();

    // 事件处理：一旦连接触发了事件，就调用这个函数，EventLoop模块只管监控触发何种事件,调用Channel处理函数
    // 如何处理由Channel决定
    void HandleEvent()
    {
        if ((_revents & EPOLLIN) || (_revents & EPOLLRDHUP) || (_revents & EPOLLPRI))
        {
            // 无论什么事件，都要调用的回调函数
            if (_anyevent_callback)
                _anyevent_callback();
            if (_read_callback)
                _read_callback();
        }
        /*有可能会出现释放连接的操作，一次只处理一个*/
        if ((_revents & EPOLLOUT))
        {
            if (_anyevent_callback)
                _anyevent_callback();
            if (_write_callback)
                _write_callback();
        }
        else if ((_revents & EPOLLERR))
        {
            if (_anyevent_callback)
                _anyevent_callback(); // 出错会释放连接，放到事件处理之前调用任意事件回调
            if (_error_callback)
                _error_callback();
        }
        else if ((_revents & EPOLLHUP))
        {
            if (_anyevent_callback)
                _anyevent_callback();
            if (_close_callback)
                _close_callback();
        }
    }
};

#include <unordered_map>
#define MAX_EPOLLEVENTS 1024
class Poller
{
private:
    int _epfd;
    struct epoll_event _evs[MAX_EPOLLEVENTS];
    std::unordered_map<int, Channel *> _channels;

private:
    // 1.判断要更新事件的描述符是否存在
    bool HasChannel(Channel *channel)
    {
        auto it = _channels.find(channel->Fd());
        if (it == _channels.end())
            return false;
        return true;
    }
    // 2.针对epoll直接操作(添加、修改、移除)
    void Update(Channel *channel, int op)
    {
        // int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event);
        int fd = channel->Fd();
        struct epoll_event ev;
        ev.data.fd = fd;
        ev.events = channel->Events();
        int ret = epoll_ctl(_epfd, op, fd, &ev);
        if (ret < 0)
        {
            ERR_LOG("EPOLLCTL FAILED...");
        }
        return;
    }

public:
    Poller()
    {
        _epfd = epoll_create(MAX_EPOLLEVENTS);
        if (_epfd < 0)
        {
            ERR_LOG("EPOLL CREATE FAILED...");
            abort(); // 退出程序
        }
    }
    // 1.添加或更新描述符所监控的事件
    void UpdateEvent(Channel *channel)
    {
        bool ret = HasChannel(channel);
        if (ret == false)
        {
            // 不存在则添加
            _channels.insert(std::make_pair(channel->Fd(), channel));
            return Update(channel, EPOLL_CTL_ADD);
        }
        return Update(channel, EPOLL_CTL_MOD);
    }
    // 2.移除描述符的监控
    void RemoveEvent(Channel *channel)
    {
        auto it = _channels.find(channel->Fd());
        if (it != _channels.end())
            _channels.erase(it);
        Update(channel, EPOLL_CTL_DEL);
    }
    // 3.开始监控，获取就绪Channel，返回活跃连接
    void Poll(std::vector<Channel *> *active)
    {
        //    int epoll_wait(int epfd, struct epoll_event *events,
        //                   int maxevents, int timeout);
        // 阻塞监控，无序设置超时时间, time_out = -1：阻塞监控
        int nfds = epoll_wait(_epfd, _evs, MAX_EPOLLEVENTS, -1);
        if (nfds < 0)
        {
            if (errno == EINTR)
            {
                return;
            }
            ERR_LOG("EPOLL WAIT ERROR: %s...\n", strerror(errno));
            abort(); // 退出程序
        }
        for (int i = 0; i < nfds; i++)
        {
            auto it = _channels.find(_evs[i].data.fd);
            assert(it != _channels.end());
            it->second->SetREvent(_evs[i].events); // 设计实际就绪事件
            active->push_back(it->second);
        }
        return;
    }
};

#include <memory>
#include <functional>
#include <iostream>
#include <vector>
#include <unordered_map>
#include <cstdint>

#include <unistd.h>

using TaskFunc = std::function<void()>; // 定时任务函数类型
using ReleaseFunc = std::function<void()>;
class TimerTask
{
private:
    uint64_t _id;         // 定时器任务对象ID
    uint32_t _timeout;    // 定时任务的超时时间
    bool _canceled;       // false表示未被取消，true表示被取消
    TaskFunc _task_cb;    // 定时器对象要执行的定时任务
    ReleaseFunc _release; // 用于删除TimerWheel中保存的定时器对象信息
public:
    TimerTask(uint64_t id, uint32_t delay /*延迟时间*/, const TaskFunc &cb)
        : _id(id), _timeout(delay), _task_cb(cb), _canceled(false) {}
    ~TimerTask()
    {
        if (_canceled == false)
            _task_cb();
        _release();
    }
    void Cancel()
    {
        _canceled = true;
    }
    void SetRelease(const ReleaseFunc &cb) { _release = cb; }
    uint32_t DelayTime() { return _timeout; };
};

#include <sys/timerfd.h>

class TimerWheel
{
private:
    using WeakTask = std::weak_ptr<TimerTask>;
    using PtrTask = std::shared_ptr<TimerTask>;
    int _tick;     // tick走到哪里就释放哪里的对象，释放哪里，就相当于执行哪里的任务
    int _capacity; // 表盘最大数量---其实就是最大延迟时间
    // 当我们要二次添加同一个定时器任务对象的时候，得能够找到他们的同一个计数器，使用weak_ptr辅助shared_ptr
    // 保存所有定时器的weak_ptr对象，因为只有保存了WeakTask才有可能通过WeakTask构造出新的shared_ptr，
    // 并且他们共享计数,并且WeakTask自身不影响计数
    std::vector<std::vector<PtrTask>> _wheel;
    std::unordered_map<uint64_t, WeakTask> _timers; // 线程安全问题，通过把定时器操作放到同一线程中执行

    // 整合所加入的三个成员
    EventLoop *_loop;
    // 可读事件回调就是读取计数器，执行定时任务
    int _timerfd;                            // 定时器描述符，要添加到EventLoop中进行事件监控，才能触发事件
    std::unique_ptr<Channel> _timer_channel; // 设置timerfd的channel，可读事件回调

private:
    void RemoveTimerInfo(uint64_t id)
    {
        auto it = _timers.find(id);
        if (it != _timers.end())
        {
            _timers.erase(it);
        }
    }
    static int CreateTimerfd()
    {
        int timerfd = timerfd_create(CLOCK_MONOTONIC, 0);
        if (timerfd < 0)
        {
            ERR_LOG("TIMERFD CREATE FAILED");
            abort();
        }
        struct itimerspec itime;
        // 设置第一次超时时间为1s后
        itime.it_value.tv_sec = 1;
        itime.it_value.tv_nsec = 0;
        // 第一次超时后，每次超时的间隔时间
        itime.it_interval.tv_sec = 1;
        itime.it_interval.tv_nsec = 0;
        timerfd_settime(timerfd, 0, &itime, NULL);
        return timerfd;
    }
    int ReadTimefd()
    {
        uint64_t times;
        // 有可能因为其他描述符的事件处理花费时间比较长，然后在处理定时器描述符事件的时候，有可能已经超时了很多次
        // read读取到的数据times就是从上一次read之后，超时的次数，Ontime多次超时，被当做一次处理
        int ret = read(_timerfd, &times, 8);
        if (ret < 0)
        {
            ERR_LOG("READ TIMEFD FAILED...");
            abort();
        }
        return times;
    }
    // 这个函数每秒钟执行一次，相当于秒针向后走了一步
    void RunTimerTask()
    {
        _tick = (_tick + 1) % _capacity;
        _wheel[_tick].clear(); // 清空指定位置的数组，就能将数组中保存的所有管理对象的shared_ptr释放掉
    }
    // 时间到了，读取Timefd，执行定时任务
    void Ontime()
    {
        int times = ReadTimefd();
        for (int i = 0; i < times; i++)
        {
            RunTimerTask();
        }
    }
    void TimerAddInLoop(uint64_t id, uint32_t delay, const TaskFunc &cb)
    {
        PtrTask pt(new TimerTask(id, delay, cb));
        pt->SetRelease(std::bind(&TimerWheel::RemoveTimerInfo, this, id));
        int pos = (_tick + delay) % _capacity;
        _wheel[pos].push_back(pt);
        _timers[id] = WeakTask(pt);
    }

    // 刷新/延迟定时任务
    void TimerRefreshInLoop(uint64_t id)
    {
        // 通过保存的定时器对象的weak_ptr构造一个shared_ptr出来，添加到轮子中
        auto it = _timers.find(id);
        if (it == _timers.end())
        {
            // 没找到定时任务，没法刷新，没法延时
            return;
        }
        PtrTask pt = it->second.lock(); // lock获取weak_ptr所管理对象对应的的shared_ptr
        int delay = pt->DelayTime();
        int pos = (_tick + delay) % _capacity;
        _wheel[pos].push_back(pt);
    }
    // 取消一个定时任务
    void TimerCancelInLoop(uint64_t id)
    {
        // 通过保存的定时器对象的weak_ptr构造一个shared_ptr出来，添加到轮子中
        auto it = _timers.find(id);
        if (it == _timers.end())
        {
            // 没找到定时任务，没法刷新，没法延时
            return;
        }
        PtrTask pt = it->second.lock(); // lock获取weak_ptr所管理对象对应的的shared_ptr
        if (pt)
            pt->Cancel();
    }

public:
    TimerWheel(EventLoop *loop) : _capacity(60), _tick(0), _wheel(_capacity), _loop(loop),
                                  _timerfd(CreateTimerfd()), _timer_channel(new Channel(_loop, _timerfd))
    {
        _timer_channel->SetReadCallBack(std::bind(&TimerWheel::Ontime, this));
        _timer_channel->EnableRead(); // 启动读事件监控
    }
    // 添加定时任务 ---> 放到EventLoop去执行
    // 因为许多定时任务都涉及到对连接的操作，需要考虑到线程安全
    /*定时器中有个_timers成员，定时器信息的操作有可能在多线程中进行，因此需要考虑线程安全问题*/
    /*如果不想加锁，那就把对定期的所有操作，都放到一个线程中进行*/
    void TimerAdd(uint64_t id, uint32_t delay, const TaskFunc &cb);
    // 刷新到任务队列中
    void TimerRefresh(uint64_t id);
    // 取消一个定时任务
    void TimerCancel(uint64_t id);
    // 存在线程安全问题
    bool HasTimer(uint64_t id)
    {
        auto it = _timers.find(id);
        if (it == _timers.end())
        {
            // 没找到定时任务，没法刷新，没法延时
            return false;
        }
        return true;
    }
};

#include <mutex>
#include <bits/std_thread.h>
#include <stdint.h>
#include <sys/eventfd.h>
class EventLoop
{
private:
    using Functor = std::function<void()>;

    std::thread::id _thread_id;
    int _event_fd; // eventfd唤醒IO事件监控有可能导致的阻塞
    // Channel *_event_channel; // 注意EventLoop析构，但是_event_channel并不会被释放，所以要在析构里delete
    // 所以使用unique_str将该指针管理起来，EventLoop释放的时候
    //  ，unique_ptr也会释放，连带所管理的_event_channel一并释放
    std::unique_ptr<Channel> _event_channel;
    Poller _poller;              // 进行所有描述符的事件监控
    std::vector<Functor> _tasks; // 任务池
    std::mutex _mutex;

    TimerWheel _timer_wheel; // 定时器模块

private:
    // 执行任务池中的所有任务
    void RunAllTask()
    {
        std::vector<Functor> functor;
        {
            std::unique_lock<std::mutex> _lock(_mutex); // 出作用域解锁
            _tasks.swap(functor);                       // functor中保存所有的任务
        }
        for (auto &f : functor)
        {
            f();
        }
        return;
    }
    //
    static int CreateEventFd()
    {
        int efd = eventfd(0, EFD_CLOEXEC | EFD_NONBLOCK);
        if (efd < 0)
        {
            ERR_LOG("CREATE EVENTFD FAILED!!");
            abort();
        }
        return efd;
    }
    void ReadEventFd()
    {

        uint64_t res = 0;
        // 读取事件
        int ret = read(_event_fd, &res, sizeof(res));
        if (ret < 0)
        {
            // EINTR:被信号打断，EAGAIN:无数据可读
            if (errno == EINTR || errno == EAGAIN)
            {
                return;
            }
            ERR_LOG("READ EVENTFD FAILED");
        }
        return;
    }
    void WeakUpEvented()
    {
        // 给Eventfd写入数据
        uint64_t val = 1;
        int ret = write(_event_fd, &val, sizeof(val));
        if (ret < 0)
        {
            if (errno == EINTR)
            {
                return;
            }
            ERR_LOG("READ EVENTFD FAILED");
        }
        return;
    }

public:
    EventLoop()
        : _thread_id(std::this_thread::get_id()), _event_fd(CreateEventFd()), _event_channel(new Channel(this, _event_fd)) // 注意_event_fd要先定义
          ,
          _timer_wheel(this)
    {
        // 给eventfd添加可读事件回调函数，读取eventfd事件通知次数
        _event_channel->SetReadCallBack(std::bind(&EventLoop::ReadEventFd, this));
        // 启动eventfd的读事件监控
        _event_channel->EnableRead();
    }
    // 启动EventLoop模块：1.先进行任务监控，2.接下来处理就绪事件，事件处理完了，3.执行任务池
    void Start()
    {
        while (1)
        {
            // 1.事件监控
            std::vector<Channel *> actives;
            _poller.Poll(&actives);
            for (auto &channel : actives)
            { // 2.事件处理
                channel->HandleEvent();
            }
            // 3.事件处理完了，执行任务
            RunAllTask();
        }
    }

    // 判断任务所在的线程是否是在当前的线程中不断处理的事件处理循环
    bool IsInLoop()
    {
        return (_thread_id == std::this_thread::get_id());
    }

    void AssertInLoop()
    {
        assert(_thread_id == std::this_thread::get_id());
    }

    // 判断将要执行的任务是否处于当前线程中，如果是则执行，不是则压入队列
    void RunInLoop(const Functor &cb)
    {
        if (IsInLoop())
        {
            return cb();
        }
        return QueueInLoop(cb);
    }
    // 将操作压入任务池
    void QueueInLoop(const Functor &cb)
    {
        {
            std::unique_lock<std::mutex> _lock(_mutex);
            _tasks.push_back(cb);
        }
        // 唤醒有可能因为没有事件就绪而导致的epoll阻塞
        // 其实就是给Eventfd写入一个数据，eventfd就会出发可读事件
        WeakUpEvented();
    }

    // 修改/添加描述符的事件监控
    void UpdateEvent(Channel *channel) { return _poller.UpdateEvent(channel); }
    // 移除描述符的所有监控
    void RemoveEvent(Channel *channel) { return _poller.RemoveEvent(channel); }
    // 添加定时器任务
    void TimerAdd(uint64_t id, uint32_t delay, const TaskFunc &cb) { return _timer_wheel.TimerAdd(id, delay, cb); }
    // 刷新定时任务
    void TimerRefresh(uint64_t id) { return _timer_wheel.TimerRefresh(id); }
    // 取消定时任务
    void TimerCancel(uint64_t id) { return _timer_wheel.TimerCancel(id); }
    bool HasTimer(uint64_t id) { return _timer_wheel.HasTimer(id); }
};

#include <condition_variable>
class LoopThread
{
private:
    // 用于实现_loop获取的同步关系：避免线程创建了，但是_loop还没有实例化完成就获取loop
    std::mutex _mutex;             // 互斥锁
    std::condition_variable _cond; // 条件变量

    std::thread _loop_thread; // EventLoop对应的线程
    EventLoop *_loop;         // 先定义一个EventLoop指针，在线程内部实例化
    // 实例化 EventLoop 对象，唤醒_cond上有可能阻塞的线程，并且开始运行EventLoop模块的功能
    void ThreadEntry()
    {
        EventLoop loop;
        {
            std::unique_lock<std::mutex> lock(_mutex);
            _loop = &loop;
            _cond.notify_all();
        }
        loop.Start();
    }

public:
    // 创建线程，设定线程入口函数
    LoopThread() : _loop(NULL), _loop_thread(std::thread(&LoopThread::ThreadEntry, this))
    {
    }
    // 未来返回线程对应的EventLoop对象指针，将某个连接和该loop关联起来
    EventLoop *GetLoop()
    {
        EventLoop *loop = NULL;
        {
            std::unique_lock<std::mutex> lock(_mutex);
            _cond.wait(lock, [&]()
                       { return _loop != nullptr; }); // loop为空就一直阻塞
            loop = _loop;
            return loop;
        }
    }
};

class LoopThreadPool
{
private:
    int _thread_count; // 从属线程的数量
    int _next_loop_idx;
    EventLoop *_baseloop;               // 主EventLoop，运行在主线程，从属线程数量为0，则所有操作都在_baseloop中进行
    std::vector<LoopThread *> _threads; // 保存所有的LoopThread对象
    std::vector<EventLoop *> _loops;    // 从属线程数量大于0则从_loops中进行线程EventLoop分配
public:
    LoopThreadPool(EventLoop *baseloop) : _thread_count(0), _next_loop_idx(0), _baseloop(baseloop)
    {
    }
    // 线程数量的设置
    void SetThreadCount(int count)
    {
        _thread_count = count;
    }
    // 创建所有的从属Reactor线程
    void Create()
    {
        if (_thread_count > 0)
        {
            _threads.resize(_thread_count);
            _loops.resize(_thread_count);
            for (int i = 0; i < _thread_count; i++)
            {
                _threads[i] = new LoopThread();
                _loops[i] = _threads[i]->GetLoop();
            }
        }
    }
    EventLoop *NextLoop()
    {
        if (_thread_count == 0)
        {
            return _baseloop;
        }
        _next_loop_idx = (_next_loop_idx + 1) % _thread_count;
        return _loops[_next_loop_idx];
    }
};

#include <typeinfo>

class Any
{
private:
    class holder
    {

    public:
        virtual ~holder() {}
        virtual const std::type_info &type() = 0;
        // 深拷贝支持：多态克隆确保复制完整对象
        virtual holder *clone() = 0;
    };
    template <class T>
    class placeholder : public holder
    {
    public:
        placeholder(const T &val) : _val(val) {}
        // 获取子类对象保存的数据类型
        const std::type_info &type() override
        {
            return typeid(T);
        }

        // 针对当前的对象自身，克隆出一个新的子类对象
        holder *clone() override
        {
            return new placeholder(_val);
        }

    public:
        T _val;
    };
    // 指向不同类型数据的通用接口
    holder *_content; // 在new一个子类对象的时候指定类型，让父类指向这个子类

public:
    // 无参构造
    Any() : _content(nullptr)
    {
    }
    template <class T>
    // 通用构造
    Any(const T &val) : _content(new placeholder<T>(val))
    {
    }
    // 拷贝构造
    Any(const Any &other) : _content(other._content ? other._content->clone() : nullptr)
    {
    }
    ~Any()
    {
        delete _content;
    }
    //&为了进行一个连续的交换
    Any &swap(Any &other)
    {
        std::swap(_content, other._content);
        return *this;
    }

    // 返回在子类对象中保存的数据的指针
    template <class T>
    T *get()
    {
        // if (!_content)
        //     return nullptr;
        // 想要获取的数据类型必须和保存的数据类型一致
        assert(typeid(T) == _content->type());
        // 向下转型获取存储的值
        return &static_cast<placeholder<T> *>(_content)->_val;
    }
    // 赋值运算符的重载函数
    template <class T>
    Any &operator=(const T &val)
    {
        // 为val构造一个临时的通用容器，然后与当前容器自身进行指针交换，临时对象释放的时候，原先保存的数据也就被释放
        Any(val).swap(*this); // 创建临时对象并交换
        return *this;
    }

    Any &operator=(const Any &other)
    {
        Any(other).swap(*this); // 拷贝构造临时对象并交换

        return *this;
    }
};

class Connection;
typedef enum
{
    DISCONNECTED, // 连接关闭状态
    CONNECTING,   // 连接建立成功，待处理的状态
    CONNECTED,    // 连接建立完成状态各种设置已完成，通信状态
    DISCONNECTING // 待关闭连接的状态
} ConnStatus;
using PtrConnection = std::shared_ptr<Connection>;
class Connection : public std::enable_shared_from_this<Connection>
{
private:
    uint64_t _conn_id; // 连接的唯一ID，便于连接的管理和查找
    // uint64_t _timer_id;         //定时器ID, 这块为了简化操作使用conn_id作为定时器ID
    int _sockfd;                   // 连接关联的文件描述符
    bool _enable_inactive_release; // 连接是否启动非活跃销毁的片判断标志，默认是false
    EventLoop *_loop;              // 连接锁关联的一个EventLoop
    ConnStatus _status;            // 连接状态
    Socket _socket;                // 套接字操作管理
    Channel _channel;              // 连接的事件管理
    Buffer _in_buffer;             // 输入缓冲区 -- 存放从socket中读取到的数据
    Buffer _out_buffer;            // 输出缓冲区 -- 存放要发送给对端的数据
    Any _context;                  // 请求的接收处理上下文

    // 这四个回调函数，是给组件使用者设置的（服务器模块来设置的，其实服务器模块的处理回调是组建使用者设置的
    // 换句话说，这几个回调都是组件使用者使用的
    using ConnectedCallBack = std::function<void(const PtrConnection &)>;
    using MessageCallBack = std::function<void(const PtrConnection &, Buffer *)>;
    using ClosedCallBack = std::function<void(const PtrConnection &)>;
    using AnyEventCallBack = std::function<void(const PtrConnection &)>;

    ConnectedCallBack _connected_callback;
    MessageCallBack _message_callback;
    ClosedCallBack _closed_callback;
    AnyEventCallBack _anyevent_callback;
    // 组件内的连接关闭回调---组件内设置的，因为服务器组件内会把所有的连接管理起来，一旦某个连接要关闭
    // 就应该从管理的地方移除掉自己的信息
    ClosedCallBack _server_closed_callback;

private:
    /*五个channel的事件回调函数*/
    // fd可读事件触发后，调用的函数，接收socket数据放到接收缓冲区中，然后调用_message_callback
    void HandleRead()
    {
        // 1.读取接收socket的数据，放到缓冲区
        char buf[65536];
        ssize_t ret = _socket.NonBlockRecv(buf, 65535);

        // 处理错误
        if (ret < 0)
        {
            // 出错了,不能直接关闭连接
            return ShutdownInLoop();
        }

        // 这里的等于0表示的是没有读取到数据，而不是连接断开了，连接断开返回的是-1
        // 将读取到的数据放入输入缓冲区，写入之后将写偏移向后移动
        _in_buffer.WriteAndPush(buf, ret);
        // 2.调用message_callback进行业务处理
        if (_in_buffer.ReadableSize() > 0)
        {
            // shared_from_this()：从当前对象自身获取到他的智能指针shared_ptr
            // (需要继承模版类enable_shared_from_this<Connection>：
            // 实例化智能指针对象之后内部会生成一个当前对象的weak_ptr，通过weak_ptr获取shared_ptr)
            return _message_callback(shared_from_this(), &_in_buffer);
        }
    }
    // fd可写事件触发后，调用的函数，将发送缓冲区中的数据进行发送
    void HandleWrite()
    {
        ssize_t ret = _socket.NonBlockSend(_out_buffer.ReadPosition(), _out_buffer.ReadableSize());
        if (ret < 0)
        {
            // 发送错误，关闭连接
            if (_in_buffer.ReadableSize() > 0)
            {
                _message_callback(shared_from_this(), &_in_buffer);
            }
            return Release(); // 实际的关闭释放操作
        }
        _out_buffer.MoveReadOffset(ret); // 一定不能忘记，移动读偏移
        if (_out_buffer.ReadableSize() == 0)
        {
            _channel.DisableWrite(); // 关闭写事件监控
            // 如果当前是连接关闭状态，则有数据，发送完数据释放连接，无数据，直接释放
            if (_status == DISCONNECTING)
            {
                return Release(); // 实际的关闭释放操作
            }
        }
        return;
    }
    // fd挂断事件触发后
    void HandleClose()
    {
        // 一旦连接挂断，socket就什么都干不了了，因此有数据先处理再关
        if (_in_buffer.ReadableSize() > 0)
        {
            _message_callback(shared_from_this(), &_in_buffer);
        }
        return Release(); // 实际的关闭释放操作
    }
    // fd出错事件触发后
    void HandleError()
    {
        return HandleClose();
    }
    // 任何事件触发后
    void HandleAnyEvent()
    {
        // 1.刷新连接活跃度（延迟定时销毁任务）2.调用组件使用者的任意事件回调
        if (_enable_inactive_release == true)
        {
            _loop->TimerRefresh(_conn_id);
        }
        if (_anyevent_callback)
        {
            _anyevent_callback(shared_from_this());
        }
    }

    // 对外提供的接口都要放在线程当中来运行

    // 连接获取之后，所处的状态下要进行各种设置（给channel设置事件回调，启动读监控）
    void EstablishedInLoop()
    {
        // 1.修改连接状态   2.启动读事件监控    3.调用回调函数
        assert(_status == CONNECTING); // 当前必须处于上层半连接状态
        _status = CONNECTED;
        // 一旦启动读事件监控（不能放在构造函数中），就有可能立即触发读事件，
        // 若这时候启动了非活跃连接销毁，就会刷新活跃度，若放到构造函数中，
        // 此时还没有添加定时任务，逻辑出现错误，
        // 启动读事件监控需要在：设置了活跃连接是否销毁之后再执行
        _channel.EnableRead();
        if (_connected_callback)
            _connected_callback(shared_from_this());
    }
    // 这个接口才是实际的释放接口
    void ReleaseInLoop()
    {
        // 1.修改连接状态DISCONNECTED
        _status = DISCONNECTED;
        // 2.移除连接的事件监控
        _channel.Remove();
        // 3.关闭套接字描述符
        _socket.Close();
        // 4.若当前定时器队列中还有定时销毁任务，则取消任务（防止野指针
        if (_loop->HasTimer(_conn_id))
            CancelInactiveReleaseInLoop();
        // 5.调用关闭回调函数
        // 用户级，先调用用户的回调函数：
        // 避免先移除服务器管理的连接信息，导致connection被释放，再去处理会出错
        if (_closed_callback)
            _closed_callback(shared_from_this());
        // 移除服务器内部管理的连接信息
        if (_server_closed_callback)
            _server_closed_callback(shared_from_this());
        DBG_LOG("RELEASE CONNECTION %lu", _conn_id); // 添加这行
    }

    // 这个接口并不是实际的发送接口，而只是将数据放到了发送缓冲区（实际在HandleWrite中处理（当触发可写事件后
    void SendInLoop(Buffer &buf)
    {
        if (_status == DISCONNECTED)
            return;
        _out_buffer.WriteBufferAndPush(buf);
        if (_channel.Writable() == false)
        {
            _channel.EnableWrite();
        }
    }
    // 并非实际连接释放操作，需要判断是否有数据待发送
    void ShutdownInLoop()
    {
        _status = DISCONNECTING;
        if (_in_buffer.ReadableSize() > 0)
        {
            if (_message_callback)
                _message_callback(shared_from_this(), &_in_buffer);
        }
        // 要么就是写入数据的时候出错关闭，要么就是没有带发送的数据，直接关闭
        if (_out_buffer.ReadableSize() > 0)
        {
            if (_channel.Writable() == false)
            {
                _channel.EnableWrite();
            }
        }
        if (_out_buffer.ReadableSize() == 0)
        {
            Release();
        }
    }
    // 启动非活跃连接超时释放规则
    void EnableInactiveReleaseInLoop(int sec)
    {
        // 1.将判断标志 _enable_inactive_release置为true
        _enable_inactive_release = true;
        // 2.如果当前定时销毁任务已存在，就刷新延迟一下
        if (_loop->HasTimer(_conn_id))
        {
            return _loop->TimerRefresh(_conn_id);
        }
        // 3.不存在就添加定时销毁任务

        _loop->TimerAdd(_conn_id, sec, std::bind(&Connection::Release, this));
    }

    // 关闭启动非活跃连接超时释放规则
    void CancelInactiveReleaseInLoop()
    {
        _enable_inactive_release = false;
        if (_loop->HasTimer(_conn_id))
        {
            _loop->TimerCancel(_conn_id);
        }
    }
    // 切换协议，升级协议
    void UpgradeInLoop(const Any &context,
                       const ConnectedCallBack &conn,
                       const MessageCallBack &msg,
                       const ClosedCallBack &closed,
                       const AnyEventCallBack &anyevent)
    {
        _context = context;
        _connected_callback = conn;
        _message_callback = msg;
        _closed_callback = closed;
        _anyevent_callback = anyevent;
    }

public:
    // 接口设计
    Connection(EventLoop *loop, uint64_t conn_id, int sockfd)
        : _conn_id(conn_id), _sockfd(sockfd), _enable_inactive_release(false), _loop(loop), _status(CONNECTING), _socket(sockfd), _channel(loop, sockfd)
    {
        _channel.SetCloseCallBack(std::bind(&Connection::HandleClose, this));
        _channel.SetAnyEventCallBack(std::bind(&Connection::HandleAnyEvent, this));
        _channel.SetReadCallBack(std::bind(&Connection::HandleRead, this));
        _channel.SetWriteCallBack(std::bind(&Connection::HandleWrite, this));
        _channel.SetErrorCallBack(std::bind(&Connection::HandleError, this));
    }
    ~Connection()
    {
        DBG_LOG("RELEASE CONNECTION: %p", this);
    }
    // 获取管理的文件描述符
    int Fd()
    {
        return _sockfd;
    }
    // 获取连接ID
    int Id()
    {
        return _conn_id;
    }
    // 返回状态
    ConnStatus Status()
    {
        return _status;
    }
    // 是否处于连接状态
    bool Connected()
    {
        return (_status == CONNECTED);
    }
    // 设置上下文 --- 连接建立完成时进行调用（CONNECTED)
    void SetContext(const Any &context)
    {
        _context = context;
    }
    // 获取上下文 --- 返回的是指针
    Any *GetContext()
    {
        return &_context;
    }

    void SetConnectedCallBack(const ConnectedCallBack &cb)
    {
        _connected_callback = cb;
    }
    void SetMessageCallBack(const MessageCallBack &cb)
    {
        _message_callback = cb;
    }
    void SetClosedCallBack(const ClosedCallBack &cb)
    {
        _closed_callback = cb;
    }
    void SetAnyEventCallBack(const AnyEventCallBack &cb)
    {
        _anyevent_callback = cb;
    }
    void SetSvrClosedCallBack(const AnyEventCallBack &cb)
    {
        _server_closed_callback = cb;
    }

    // 连接建立就绪后，进行channel回调设置，启动读监控
    void Established()
    {
        _loop->RunInLoop(std::bind(&Connection::EstablishedInLoop, this));
    }

    // 发送数据，将数据发送到缓冲区，启动写事件监控
    void Send(const char *data, size_t len)
    {
        Buffer buf;
        buf.WriteAndPush(data, len);
        _loop->RunInLoop(std::bind(&Connection::SendInLoop, this, std::move(buf)));
    }
    // 提供给组件使用者的关闭接口, 并不实际关闭，需要判断是否有数据待处理
    void Shutdown()
    {
        _loop->RunInLoop(std::bind(&Connection::ShutdownInLoop, this));
    }

    void Release()
    {
        _loop->QueueInLoop(std::bind(&Connection::ReleaseInLoop, this));
    }
    // 启动非活跃销毁，并定义多长时间无通信，并定义多长时间无通信就是非活跃，添加定时任务
    void EnableInactiveRelease(int sec)
    {
        _loop->RunInLoop(std::bind(&Connection::EnableInactiveReleaseInLoop, this, sec));
    }
    // 取消非活跃销毁
    void CancelInactiveRelease()
    {
        _loop->RunInLoop(std::bind(&Connection::CancelInactiveReleaseInLoop, this));
    }

    // 切换协议 --- 重置上下文以及阶段性处理函数--而是这个接口必须在EventLoop线程中立即执行
    // 防备新的事件触发后处理的时候，切换任务还没有被执行，会导致数据使用原协议处理
    void Upgrade(const Any &context,
                 const ConnectedCallBack &conn,
                 const MessageCallBack &msg,
                 const ClosedCallBack &closed,
                 const AnyEventCallBack &anyevent)
    {
        _loop->AssertInLoop();
        _loop->RunInLoop(std::bind(&Connection::UpgradeInLoop, this, context, conn, msg, closed, anyevent));
    }
};

class Acceptor
{
private:
    Socket _socket;   // 用于创建监听套接字
    EventLoop *_loop; // 用于对监听套接字进行事件监控
    Channel _channel; // 用于对监听套接字进行事件管理
    using AcceptCallBack = std::function<void(int)>;
    AcceptCallBack _accept_callback;

private:
    // 监听套接字的读事件回调函数，获取新连接，调用_accept_callback回调函数进行新连接的处理
    void HandleRead()
    {
        DBG_LOG("ACCEPTOR HANDLE READ...");
        int newfd = _socket.Accept();
        if (newfd < 0)
        {
            return;
        }
        if (_accept_callback)
            _accept_callback(newfd);
    }
    int CreateServer(int port)
    {
        bool ret = _socket.CreateServer(port);
        assert(ret == true);
        return _socket.Fd();
    }

public:
    // 不能将启动读事件监控，放到构造函数中，必须在设置回调函数后，再去启动
    // 否则有可能造成启动监控后，立即有事件，处理的时候，回调函数还没有设置，新连接得不到处理，且资源泄露
    Acceptor(EventLoop *loop, int port) : _socket(CreateServer(port)), _loop(loop), _channel(loop, _socket.Fd())
    {
        _channel.SetReadCallBack(std::bind(&Acceptor::HandleRead, this));
    }
    void SetAcceptCallBack(const AcceptCallBack &cb)
    {
        _accept_callback = cb;
    }
    void Listen()
    {
        _channel.EnableRead();
    }
};

class TcpServer
{
private:
    using Functor = std::function<void()>;

    int _port;                                          // 服务器所要监听的端口
    uint64_t _next_id;                                  // 自动增长的连接ID
    int _timeout;                                       // 这是非活跃连接的统计时间---多长事件无通信就是非活跃连接
    bool _enable_inactive_release;                      // 是否启动了非活跃连接超时销毁的判断标志
    EventLoop _baseloop;                                // 这是主线程的EventLoop对象，负责监听事件的处理
    Acceptor _acceptor;                                 // 这是管理监听套接字的对象
    LoopThreadPool _pool;                               // 这是从属EventLoop线程池
    std::unordered_map<uint64_t, PtrConnection> _conns; // 保存管理所有连接对应的shared_ptr对象

    using ConnectedCallBack = std::function<void(const PtrConnection &)>;
    using MessageCallBack = std::function<void(const PtrConnection &, Buffer *)>;
    using ClosedCallBack = std::function<void(const PtrConnection &)>;
    using AnyEventCallBack = std::function<void(const PtrConnection &)>;
    ConnectedCallBack _connected_callback;
    MessageCallBack _message_callback;
    ClosedCallBack _closed_callback;
    AnyEventCallBack _anyevent_callback;

private:
    // 为新连接构造一个Connection进行管理
    void NewConnection(int fd)
    {
        // DBG_LOG("NEWCONNECTION FUNCTION");
        _next_id++;
        PtrConnection conn(new Connection(_pool.NextLoop(), _next_id, fd));
        conn->SetMessageCallBack(_message_callback);
        conn->SetClosedCallBack(_closed_callback);
        conn->SetConnectedCallBack(_connected_callback);
        conn->SetAnyEventCallBack(_anyevent_callback);
        conn->SetSvrClosedCallBack(std::bind(&TcpServer::RemoveConnection, this, std::placeholders::_1));
        if (_enable_inactive_release)
        {
            conn->EnableInactiveRelease(_timeout);
        }
        conn->Established();
        _conns.insert(std::make_pair(_next_id, conn));
        DBG_LOG("NEW CONNECTION...");
    }
    void RemoveConnectionInLoop(const PtrConnection &conn)
    {
        int id = conn->Id();
        auto it = _conns.find(id);
        if (it != _conns.end())
        {
            _conns.erase(id);
        }
    }
    // 从管理Connection的_conns中移除连接信息，连接才会真正被释放
    void RemoveConnection(const PtrConnection &conn)
    {
        _baseloop.RunInLoop(std::bind(&TcpServer::RemoveConnectionInLoop, this, conn));
    }
    void RunAfterInLoop(const Functor &task, int delay)
    {
        _next_id++;
        _baseloop.TimerAdd(_next_id, delay, task);
    }

public:
    TcpServer(int port)
        : _port(port), _next_id(0), _enable_inactive_release(false), _acceptor(&_baseloop, port), _pool(&_baseloop)
    {
        _acceptor.Listen(); // 将监听套接字挂到baseloop上开始监控事件
        _acceptor.SetAcceptCallBack(std::bind(&TcpServer::NewConnection, this, std::placeholders::_1));
    }
    // 设置线程数
    void SetThreadCount(int count)
    {
        return _pool.SetThreadCount(count);
    }
    // 回调函数的设置
    void SetConnectedCallBack(const ConnectedCallBack &cb)
    {
        _connected_callback = cb;
    }
    void SetMessageCallBack(const MessageCallBack &cb)
    {
        _message_callback = cb;
    }
    void SetClosedCallBack(const ClosedCallBack &cb)
    {
        _closed_callback = cb;
    }
    void SetAnyEventCallBack(const AnyEventCallBack &cb)
    {
        _anyevent_callback = cb;
    }
    void EnableInactiveRelease(int timeout)
    {
        _timeout = timeout;
        _enable_inactive_release = true;
    }
    // 用于添加一个定时任务
    void RunAfter(const Functor &task, int delay)
    {
        _baseloop.RunInLoop(std::bind(&TcpServer::RunAfterInLoop, this, task, delay));
    }
    void Start()
    {
        _pool.Create(); // 创建线程池中的从属线程

        return _baseloop.Start();
    }
};

void Channel::Remove() { return _loop->RemoveEvent(this); }
void Channel::Update() { return _loop->UpdateEvent(this); }
void TimerWheel::TimerAdd(uint64_t id, uint32_t delay, const TaskFunc &cb)
{
    _loop->RunInLoop(std::bind(&TimerWheel::TimerAddInLoop, this, id, delay, cb));
}
void TimerWheel::TimerRefresh(uint64_t id)
{
    _loop->RunInLoop(std::bind(&TimerWheel::TimerRefreshInLoop, this, id));
}
void TimerWheel::TimerCancel(uint64_t id)
{
    _loop->RunInLoop(std::bind(&TimerWheel::TimerCancelInLoop, this, id));
}

#include <csignal>
class NetWork
{
public:
    NetWork()
    {
        DBG_LOG("SIGPIPE INIT...");
        // 当连接断开，若仍然Send，Send就会触发异常SIGPIPE，会导致程序的退出，我们通过信号忽略方法将SIGPIPE信号忽略
        signal(SIGPIPE, SIG_IGN);
    }
};

static NetWork nw;

#endif